home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 25 / CU Amiga Magazine's Super CD-ROM 25 (1998)(EMAP Images)(GB)(Track 1 of 2)[!][issue 1998-08].iso / CUCD / Programming / QuakeTools / src / libqtools / raw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-11  |  11.4 KB  |  448 lines
  1. #define    LIBQTOOLS_CORE
  2. #include "../include/libqtools.h"
  3.  
  4. /*
  5.  * pmalloc/pfree
  6.  */
  7.  
  8. struct palpic *pmalloc(register short int width, register short int height, register struct rgb *palette, register char *picName) {
  9.   struct palpic *Picture = 0;
  10.  
  11.   if ((Picture = (struct palpic *)tmalloc((width * height) + sizeof(struct palpic)))) {
  12.     Picture->width = width;
  13.     Picture->height = height;
  14.     if(!palette)
  15.       palette = GetPalette();
  16.     Picture->palette = palette;
  17.     if(!picName)
  18.       picName = "nameLess";
  19.     Picture->name = smalloc(picName);
  20.   }
  21.   else
  22.     eprintf("cannot tmalloc %ld bytes memory for palpic\n", (width * height) + sizeof(struct palpic));
  23.   
  24.   return Picture;
  25. }
  26.  
  27. bool pfree(register struct palpic *Picture) {
  28.   if(Picture) {
  29.     if(Picture->palette)
  30.       tfree(Picture->palette);
  31.     if(Picture->name)
  32.       tfree(Picture->name);
  33.     tfree(Picture);
  34.     return TRUE;
  35.   }
  36.   else
  37.     return FALSE;
  38. }
  39.  
  40. struct rawdata *rmalloc(register int size, register char *rawName) {
  41.   struct rawdata *rawData = 0;
  42.  
  43.   if ((rawData = (struct rawdata *)tmalloc(size + sizeof(struct rawdata)))) {
  44.     rawData->size = size;
  45.     if(!rawName)
  46.       rawName = "nameLess";
  47.     rawData->name = smalloc(rawName);
  48.   }
  49.   else
  50.     eprintf("cannot tmalloc %ld bytes memory for rawdata\n", size + sizeof(struct rawdata));
  51.   
  52.   return rawData;
  53. }
  54.  
  55. void rfree(register struct rawdata *rawData) {
  56.   if(rawData) {
  57.     if(rawData->name)
  58.       tfree(rawData->name);
  59.     tfree(rawData);
  60.   }
  61. }
  62.  
  63. /*
  64.  * palette
  65.  */
  66.  
  67. FILE *palFile = 0, *colrFile = 0, *transFile = 0;
  68. short int darkness = 0, transparency = -1;
  69. struct rgb *cachedPalette = 0;
  70. unsigned char *cachedColormap = 0;
  71. unsigned char *cachedTransparency = 0;
  72.  
  73. unsigned char *GetTransparency(int transVal) {
  74.   char transTemplate[NAMELEN_PATH + 1] = "TArray.%2d";
  75.   char transName[NAMELEN_PATH + 1] = "TArray.??";
  76.   unsigned char *NewTransparency;
  77.  
  78.   if((NewTransparency = (unsigned char *)tmalloc(256 * 256 * sizeof(unsigned char)))) {
  79. //mprintf("allocated\n");
  80.     if(!cachedTransparency || (transVal != transparency)) {
  81. //mprintf("wrong cache\n");
  82.       sprintf(transName, transTemplate, transVal);
  83.       if (!(transFile = fopen(transName, READ_BINARY))) {
  84.         char *transBase;
  85. //mprintf("can't open local\n");
  86.           
  87.     if((transBase = getenv("QUAKE_TRANSPARENCY"))) {
  88. //mprintf("try environment\n");
  89.       strncpy(transName, transBase, NAMELEN_PATH);
  90.       strncat(transName, transTemplate, NAMELEN_PATH);
  91.       strcpy(transTemplate, transName);
  92.           sprintf(transName, transTemplate, transVal);
  93.           transFile = fopen(transName, READ_BINARY);
  94.         }
  95.       }
  96.       
  97.       if(!transFile) {
  98.     int i, j;
  99.     struct rgb *actPel;
  100.  
  101.         mprintf("build transparency for density %2d\n", transVal);
  102.     
  103.     for (i = 0; i < 256; i++) {
  104.       actPel = &cachedPalette[i];
  105.       for (j = 0; j < 256; j++) {
  106.         int R, G, B;
  107.         struct rgb matchPel;
  108.         
  109.         R = ((((int)(cachedPalette[j].r - actPel->r) * transVal) / 100) + (int)actPel->r);
  110.         G = ((((int)(cachedPalette[j].g - actPel->g) * transVal) / 100) + (int)actPel->g);
  111.         B = ((((int)(cachedPalette[j].b - actPel->b) * transVal) / 100) + (int)actPel->b);
  112.         
  113.         matchPel.r = (unsigned char)R;
  114.         matchPel.g = (unsigned char)G;
  115.         matchPel.b = (unsigned char)B;
  116.         NewTransparency[(i << 8) + j] = Match(&matchPel, cachedPalette);
  117.       }
  118.       mprogress(256, i + 1);
  119.     }
  120.  
  121.         if ((transFile = fopen(transName, WRITE_BINARY)))
  122.           fwrite(NewTransparency, 256, 256 * sizeof(unsigned char), transFile);
  123.       }
  124.       else
  125.         fread(NewTransparency, 256, 256 * sizeof(unsigned char), transFile);
  126.  
  127.       if(transFile) {
  128.         fclose(transFile);
  129.         transFile = 0;
  130.       }
  131.       if(cachedTransparency)        /* release wrong cached transval */
  132.         tfree(cachedTransparency);
  133.  
  134.       transparency = transVal;
  135.       cachedTransparency = NewTransparency;
  136.       NewTransparency = GetTransparency(transVal);
  137. //mprintf("got it\n");
  138.     }
  139.     else    
  140.       memcpy(NewTransparency, cachedTransparency, 256 * 256 * sizeof(unsigned char));
  141.   }
  142. //mprintf("return %lx\n", NewTransparency);
  143.   return NewTransparency;
  144. }
  145.  
  146. struct rgb *GetDarkness(struct rgb *Palette) {
  147.   struct rgb *NewPalette;
  148.         
  149.   if((NewPalette = (struct rgb *)tmalloc(256 * 3))) {
  150.     short int i;
  151.  
  152.     if(!cachedColormap) {
  153.       bool closecolr = FALSE;
  154.       unsigned char *DarkLevel;
  155.           
  156.       if((DarkLevel = (unsigned char *)tmalloc(256 * 64))) {
  157.         
  158.         if (!colrFile) {
  159.           if (!(colrFile = fopen("colormap.lmp", READ_BINARY))) {
  160.             char *colrName;
  161.                   
  162.             if((colrName = getenv("QUAKE_COLORMAP"))) {
  163.               if (!(colrFile = fopen(colrName, READ_BINARY)))
  164.               eprintf("no colormap available, build new from scratch\n");
  165.               else
  166.             closecolr = TRUE;
  167.         }
  168.         else
  169.           eprintf("no colormap available, build new from scratch\n");
  170.           }
  171.           else
  172.         closecolr = TRUE;
  173.         }
  174.         
  175.         if(colrFile) {
  176.           fread(DarkLevel, 1, 256 * 64, colrFile);
  177.           if (closecolr == TRUE)
  178.             fclose(colrFile);
  179.           else
  180.             fseek(colrFile, 0, SEEK_SET);
  181.         }
  182.         else {
  183.           /* TODO: how to build colormap */
  184.         }
  185.               
  186.         cachedColormap = DarkLevel;
  187.       }
  188.       else {
  189.         eprintf("failed to allocate colormap\n");
  190.         return Palette;
  191.       }
  192.     }
  193.   
  194.     for (i = 256; i < 256; i++)
  195.       NewPalette[i] = Palette[cachedColormap[i]];
  196.  
  197.     tfree(Palette);
  198.   }
  199.   
  200.   if(NewPalette)
  201.     return NewPalette;
  202.   else
  203.     return Palette;
  204. }
  205.  
  206. struct rgb *GetPalette(void) {
  207.   struct rgb *Palette;
  208.   int c = 256-1;
  209.   
  210.   if((Palette = (struct rgb *)tmalloc(256 * 3))) {
  211.     if(!cachedPalette) {
  212.       bool closepal = FALSE;
  213.   
  214.       if (!palFile) {
  215.         if (!(palFile = fopen("palette.lmp", READ_BINARY))) {
  216.           char *palName;
  217.           
  218.       if((palName = getenv("QUAKE_PALETTE"))) {
  219.             if (!(palFile = fopen(palName, READ_BINARY))) {
  220.               eprintf("no palette available\n");
  221.               tfree(Palette);
  222.               return 0;
  223.             }
  224.             else
  225.               closepal = TRUE;
  226.           }
  227.           else {
  228.             eprintf("no palette available\n");
  229.             tfree(Palette);
  230.             return 0;
  231.           }
  232.         }
  233.         else
  234.           closepal = TRUE;
  235.       }
  236.       
  237.       fread(Palette, 1, 256 * 3, palFile);
  238.  
  239.       if (closepal == TRUE)
  240.         fclose(palFile);
  241.       else
  242.         fseek(palFile, 0, SEEK_SET);
  243.       
  244.       /*
  245.        * small trick
  246.        */
  247.       cachedPalette = Palette;
  248.       Palette = GetPalette();
  249.     }
  250.     else
  251.       memcpy(Palette, cachedPalette, 256 * 3);
  252.   }
  253.  
  254.   if (darkness)
  255.     Palette = GetDarkness(Palette);
  256.  
  257.   return Palette;
  258. }
  259.  
  260. /*
  261.  * Lumps
  262.  */
  263. struct palpic *GetLMP(register FILE *file, register char *lmpName) {
  264.   struct lump Lump;
  265.   struct palpic *Picture;
  266.  
  267.   fread(&Lump, 1, sizeof(struct lump), file);
  268.   if ((Picture = pmalloc(LittleLong(Lump.width), LittleLong(Lump.height), 0, lmpName)))
  269.     fread(Picture->rawdata, 1, Picture->width * Picture->height, file);
  270.  
  271.   return Picture;
  272. }
  273.  
  274. struct palpic *ParseLMP(register struct lump *Lump, register char *lmpName) {
  275.   struct palpic *Picture;
  276.  
  277.   if ((Picture = pmalloc(LittleLong(Lump->width), LittleLong(Lump->height), 0, lmpName)))
  278.     memcpy(Picture->rawdata, Lump->rawdata, Picture->width * Picture->height);
  279.  
  280.   return Picture;
  281. }
  282.  
  283. bool PutLMP(register FILE *file, register struct palpic *Picture) {
  284.   struct lump Lump;
  285.   int size = sizeof(struct lump) + (Picture->width * Picture->height);
  286.  
  287.   Lump.width = LittleLong(Picture->width);
  288.   Lump.height = LittleLong(Picture->height);
  289.   fwrite(&Lump, 1, 2 * sizeof(int), file);
  290.   if(fwrite(Picture->rawdata, 1, size, file) != size)
  291.     return FALSE;
  292.   else
  293.     return TRUE;
  294. }
  295.  
  296. bool PasteLMP(register struct lump *Lump, register struct palpic *Picture) {
  297.   Lump->width = LittleLong(Picture->width);
  298.   Lump->height = LittleLong(Picture->height);
  299.   memcpy(((char *)Lump) + sizeof(struct lump), Picture->rawdata, (Picture->width * Picture->height));
  300.  
  301.   return TRUE;
  302. }
  303.  
  304. /*
  305.  * compressed
  306.  */
  307.  
  308. char Compression = CMP_NONE;
  309.  
  310. char *GetLZ77(register FILE *file, register int readsize) {
  311.   char *inData, *outData = 0;
  312.   
  313.   if (readsize == 0) {
  314.     int oldoffset = ftell(file);
  315.  
  316.     fseek(file, 0, SEEK_END);
  317.     readsize = ftell(file);
  318.     fseek(file, oldoffset, SEEK_SET);
  319.   }
  320.  
  321.   if((inData = (char *)tmalloc(readsize))) {
  322.     int size;
  323.  
  324.     fread(inData, 1, readsize, file);
  325.     if((size = LZWSSize(inData)) > ERROR) {
  326.       mprintf("prepare to decrunch %d bytes ... \n", size);
  327.       if((outData = (char *)tmalloc(size))) {
  328.         if(LZWSDecrunch(size, inData, outData) < ERROR) {
  329.           eprintf("failed to decrunch\n");
  330.           tfree(outData);
  331.           outData = 0;
  332.         }
  333.       }
  334.       else
  335.         eprintf("cannot tmalloc %d bytes memory for decrunch\n", size);
  336.     }
  337.     tfree(inData);
  338.   }
  339.   else
  340.     eprintf("cannot tmalloc %d bytes memory for readdata\n", readsize);
  341.   
  342.   return outData;
  343. }
  344.  
  345. char *ParseLZ77(register char *inData, register int readsize) {
  346.   char *outData = 0;
  347.   
  348.   if (readsize > 0) {
  349.     int size;
  350.  
  351.     if((size = LZWSSize(inData)) > ERROR) {
  352.       mprintf("prepare to decrunch %d bytes ... \n", size);
  353.       if((outData = (char *)tmalloc(size))) {
  354.         if(LZWSDecrunch(size, inData, outData) < ERROR) {
  355.           eprintf("failed to decrunch\n");
  356.           tfree(outData);
  357.           outData = 0;
  358.         }
  359.       }
  360.       else
  361.         eprintf("cannot tmalloc %d bytes memory for decrunch\n", size);
  362.     }
  363.   }
  364.   
  365.   return outData;
  366. }
  367.  
  368. int PutLZ77(register FILE *file, register char *inData, register int size) {
  369.   char *outData, *saveData;
  370.   int retval = -1;
  371.   
  372.   if((outData = (char *)tmalloc(size))) {
  373.     if((retval = LZWSCrunch(size, size, size * 2, inData, outData)) > ERROR) {
  374.       mprintf("crunched %d to %d (%d%%)\n", size, retval, ((retval * 100) / size));
  375.       if (fwrite(outData, 1, retval, file) != retval)
  376.         retval = -1;
  377.  
  378.       if((saveData = (char *)tmalloc(size))) {
  379.         int error, byte;
  380.         if((error = LZWSDecrunch(size, outData, saveData)) > ERROR) {
  381.           for(byte = 0; byte < size; byte++) {
  382.             if(inData[byte] != saveData[byte])
  383.               break;
  384.           }
  385.           if(byte != size)
  386.             eprintf("difference at %d\n", byte);
  387.         }
  388.         tfree(saveData);
  389.       }
  390.     }
  391.     tfree(outData);
  392.   }
  393.   else
  394.     eprintf("cannot tmalloc %d bytes memory for writedata\n", size);
  395.  
  396.   return retval;
  397. }
  398.  
  399. int PasteLZ77(register char *outData, register char *inData, register int size) {
  400.   return LZWSCrunch(size, size, size * 2, inData, outData);
  401. }
  402.  
  403. /*
  404.  * Unknown/Raw
  405.  */
  406. struct rawdata *GetRaw(register FILE *file, register char *rawName, register int size) {
  407.   struct rawdata *rawData = 0;
  408.  
  409.   if (size == 0) {
  410.     int oldoffset = ftell(file);
  411.  
  412.     fseek(file, 0, SEEK_END);
  413.     size = ftell(file);
  414.     fseek(file, oldoffset, SEEK_SET);
  415.   }
  416.  
  417.   if ((rawData = rmalloc(size + 1, rawName))) {
  418.     fread(rawData->rawdata, 1, size, file);
  419.     rawData->size--;
  420.   }
  421.  
  422.   return rawData;
  423. }
  424.  
  425. struct rawdata *ParseRaw(register char *mem, register char *rawName, register int size) {
  426.   struct rawdata *rawData = 0;
  427.  
  428.   if (size != 0)
  429.     if ((rawData = rmalloc(size + 1, rawName))) {
  430.       memcpy(rawData->rawdata, mem, size);
  431.       rawData->size--;
  432.     }
  433.  
  434.   return rawData;
  435. }
  436.  
  437. bool PutRaw(register FILE *file, register struct rawdata *rawData) {
  438.   if (fwrite(rawData->rawdata, 1, rawData->size, file) != rawData->size)
  439.     return FALSE;
  440.   else
  441.     return TRUE;
  442. }
  443.  
  444. bool PasteRaw(register char *mem, register struct rawdata *rawData) {
  445.   memcpy(mem, rawData->rawdata, rawData->size);
  446.   return TRUE;
  447. }
  448.